require 'sketchup.rb'
# require File.join(__FILE__, '../AF.rb')
module AMTF
  class AF匹配尺寸
    include AMTF_mixin

    def initialize()
      设置常用对象
      if @selection.count == 0
        # UI.messagebox "请先选择一个拟匹配到空间的对象(组件)"
      else
        @拟匹配对象=@selection[0]
        # 选择点偏移=ip_p.transform(transform)
        # @拟匹配对象.transform! @编辑中tr
        # p "@model.path="+@拟匹配对象.path
        @拟匹配对象.visible=false
      end
      @选择点 = Sketchup::InputPoint.new
    end

    def onMouseMove(flags, x, y, view)
      @pts = []
      @选择点.pick( view, x, y )
      if @选择点.face and @选择点.face.visible?
        ip_p = @选择点.position
        @pts.push ip_p
        face=@选择点.face
        # @selection.add(face)
        edges = face.edges
        # @selection.add(edges[0])
        # @selection.add(edges[1])
        line0 = edges[0].line
        line0向量=line0[1]
        line1 = edges[1].line
        line1向量=line1[1]

        选择面局部法向 = @选择点.face.normal#是的，返回的法向可能并不垂直于面！
        # p "选择面局部法向="+选择面局部法向.to_s
        选择点tr = @选择点.transformation
        选择面法向 = 选择面局部法向.transform( 选择点tr )
        # p "选择面法向="+选择面法向.to_s
        vector2 = 选择面法向.normalize
        # p "vector2="+vector2.to_s
        vector2.length = 1/25.4*10
        # p "vector2/25.4*10="+vector2.to_s
        transform = Geom::Transformation.new(vector2)
        选择点偏移=ip_p.transform(transform)
        # p "法向偏移后选择点坐标："+选择点偏移.to_s
        # line = @entities.add_line @原点,选择点偏移
        # @选择点=""
        @左面x=nil
        @右面x=nil
        @前面y=nil
        @后面y=nil
        @上面z=nil
        @下面z=nil

        @左h=Hash[]
        @右h=Hash[]
        @上h=Hash[]
        @下h=Hash[]
        @前h=Hash[]
        @后h=Hash[]
        选择点放射击中点h=Hash[]
        选择点偏移放射击中面h=Hash[]
        方向h=Hash[]
        # 方向h['左']=Geom::Vector3d.new(-1, 0, 0).transform(@编辑中tr)
        方向h['左']=Geom::Vector3d.new(-1, 0, 0)
        方向h['右']=方向h['左'].reverse

        # 方向h['前']=Geom::Vector3d.new(0, 1, 0).transform(@编辑中tr)
        方向h['前']=Geom::Vector3d.new(0, 1, 0)
        方向h['后']=方向h['前'].reverse

        # 方向h['上']=Geom::Vector3d.new(0, 0, 1).transform(@编辑中tr)
        方向h['上']=Geom::Vector3d.new(0, 0, 1)
        方向h['下']=方向h['上'].reverse

        方向h.each{|k,v|
          投影测试=@model.raytest([@选择点, v], true)
          if 投影测试!=nil
            击中点=投影测试[0]
            选择点放射击中点h[k]=击中点
            @pts.push 击中点
          end
          投影测试=@model.raytest([选择点偏移, v], true)
          if 投影测试!=nil
            击中面 = 投影测试[1][-1]
            选择点偏移放射击中面h[k]=击中面
          end
        }
        # plane = 选择点偏移放射击中面h['下'].plane

        point = 选择点放射击中点h['后']
        @pts.push point
        # p point
        投影测试=@model.raytest([point, 方向h['下']], true)
        @左下后点p = 投影测试[0]

        # @entities.add_cpoint @左下后点p
        @pts.push @左下后点p

        # p @左下后点p

        point = @左下后点p
        投影测试=@model.raytest([point, 方向h['右']], true)
        @右下后点p = 投影测试[0]
        @pts.push @右下后点p

        point = @右下后点p
        投影测试=@model.raytest([point, 方向h['前']], true)
        @右下前点p = 投影测试[0]
        # @pts.push @右下后点p

        point = @左下后点p
        投影测试=@model.raytest([point, 方向h['前']], true)
        @左下前点p = 投影测试[0]
        @pts.push @左下前点p

        point = @左下后点p
        投影测试=@model.raytest([point, 方向h['上']], true)
        @左上后点p = 投影测试[0]
        @pts.push @左上后点p

        p "点数组大小："+@pts.size.to_s
        view.invalidate# if @画完边框
      else
        @pts = []
      end
    end
    def activate
      @画完边框 = false
      @选择点 = Sketchup::InputPoint.new
      self.reset(nil)
    end
    def resume(view)
    end
    def deactivate(view)
      view.invalidate if @画完边框
    end
    def onCancel(flag, view)
      self.reset(view)
    end
    def reset(view)
      @选择点.clear
      @message = "选择面 以识别内空"
      @pts = []
      Sketchup.set_status_text( @message )
      if( view )
        view.tooltip = nil
        view.invalidate if @画完边框
      end
      @画完边框 = false
    end
    def draw(view)
      Sketchup.set_status_text( @message )
      if @pts != []
        view.draw_points(@pts,12, 5, "red")

        view.line_width = 4
        view.drawing_color="blue"
        view.draw_polyline(@左下后点p,@右下后点p,@右下前点p,@左下前点p,@左下后点p)
        # @selection.clear
      end
      @画完边框 = true
    end

    def onLButtonDown flags,x,y,view
      # 设置常用对象
      @width = @左下后点p.distance @右下后点p
      p "@width:"+@width.to_s
      @depth = @左下后点p.distance @左下前点p
      p @depth
      @height = @左下后点p.distance @左上后点p
      p @height
      # 断点.nil
      缩放移动对象
    end

    def 缩放移动对象()
      @model.start_operation("缩放移动对象")
      ents = @model.active_entities
      # 组件名="背板"+".skp"
      # @组件全名 = File.join(get_dir,组件名).freeze
      # if File.exist? @组件全名
      #   组件定义 = @model.definitions.load @组件全名
      #   b = 组件定义.bounds
      # end
      # b = @拟匹配对象.definitions.bounds

      #对齐到全局坐标系，获取边界框大小↓
      x = Geom::Vector3d.new(1, 0, 0)
      y = Geom::Vector3d.new(0, 1, 0)
      z = Geom::Vector3d.new(0, 0, 1)
      tr = Geom::Transformation.new(x,y,z,@左下后点p)
      @拟匹配对象.transformation = tr
      # kk.nil
      b = @拟匹配对象.bounds
      边界宽 = b.width
      p 边界宽
      边界高 = b.height
      p 边界高
      边界深 = b.depth
      p 边界深
      sr = Geom::Transformation.scaling(@左下后点p,@width/边界宽,@depth/边界高,@height/边界深)

      #对齐到根据选择点计算出来的坐标系↓……XXX组件局部坐标系会各有各样！！√√√既然是不按套路出牌的组件，只能是无缘咯）
      # x = @左下后点p.vector_to @右下后点p
      # y = @左下后点p.vector_to @左下前点p
      # z = @左下后点p.vector_to @左上后点p
      # tr = Geom::Transformation.new(x,y,z,@左下后点p)
      # @拟匹配对象.transformation = tr

      # tr = Geom::Transformation.translation(vector)
      # c.transformation = tr

      #就得先旋转，再缩放↓
      @拟匹配对象.transform! sr
      # c = ents.add_instance 组件定义,Geom::Transformation.new
      # c.make_unique
      # c.transform! sr

      @拟匹配对象.visible=true
      # p "kk:"+$dc_observers.to_s
      # $dc_observers.get_class_by_version(@拟匹配对象).redraw_with_undo(@拟匹配对象)
    end

    def 识别投影面(投影测试,h)
      选择点是击中点=false
      if 投影测试 != nil
        #     投影对象 = 投影测试[1][-1]
        #     @selection.add(投影对象)
        击中点=投影测试[0]
        p "击中点全局="+击中点.to_s
        ip_p = @选择点.position
        p "ip_p="+ip_p.to_s
        p "ip_p==击中点？"+(ip_p==击中点).to_s
        选择点是击中点=ip_p==击中点
        h['是被点面']=ip_p==击中点

        @击中面 = 投影测试[1][-1]
        @层级转换 = Geom::Transformation.new
        # p "投影测试[1]:"+ 投影测试[1].to_s
        距离编辑中组件=-1
        到达编辑中组件=false
        # @层级转换= @层级转换 * 投影测试[1][-2].transformation
        # @层级转换= @层级转换 * 投影测试[1][-3].transformation
        # @层级转换= @层级转换 * 投影测试[1][-4].transformation
        # @层级转换= @层级转换 * 投影测试[1][-5].transformation
        投影测试[1].each{|e|
          if e.kind_of? Sketchup::Group or e.kind_of? Sketchup::ComponentInstance
            # p "e:"+ e.to_s
            # p "e:"+ e.name.to_s
            # p "e:"+ e.definition.name.to_s
            # if 距离编辑中组件>0
              # p "变换了这个坐标："+e.definition.name.to_s
              tr = e.transformation
              # p "e.transformation=?"+(tr==@编辑中tr).to_s
              # p "e.transformation=?"+tr.to_a.to_s
              # p "@编辑中tr=?"+@编辑中tr.to_a.to_s
              @层级转换= @层级转换 * tr
            # end
            if 到达编辑中组件
              距离编辑中组件+=1
            end
            if e.definition.name==@编辑中组件名称
              到达编辑中组件=true
            end
          end
        }
      end
    end

    def 判断空间坐标()
      if @左h['投影面'] != nil
        零点坐标转换(@左h)
        @左面x=@左h['0点'][0]
        p "@左面x:"+@左面x.to_s
      end
      if @右h['投影面'] != nil
        零点坐标转换(@右h)
        @右面x=@右h['0点'][0]
        p "@右面x:"+@右面x.to_s
      end
      if @上h['投影面'] != nil
        零点坐标转换(@上h)
        @上面z=@上h['0点'][2]
      end
      if @下h['投影面'] != nil
        零点坐标转换(@下h)
        @下面z=@下h['0点'][2]
      end
      # if @下h['投影面'] != nil
      #   点坐标转换(@下h)
      #   @下面z=@下h['0点'][0]
      # end
    end

    def 零点坐标转换(h)
      点=h['投影面'].vertices[0]
      h['0点']=点坐标转换(点,h)
    end

    def 点坐标转换(点,h)
      vtp=点.position#返回的是局部坐标！！
      p "vtp局部："+vtp.to_s
      vtp=vtp.transform( h['层级转换'] )
      p "vtp层级转换："+vtp.to_s
      return vtp
    end

    def 识别选择面边界值(h)
      最小x=nil
      最大x=nil
      最小y=nil
      最大y=nil
      最小z=nil
      最大z=nil
      # @selection.add(面)
      面=h["投影面"]
      h["点组"]=[]
      面.vertices.each{|vt|
        vtp=点坐标转换(vt,h)
        h["点组"].push vtp
        # line = @entities.add_line  @原点, vtp
        # p "编辑中局部原点:"+@编辑中局部原点.to_s
        # vtp=@编辑中局部原点.vector_to(vtp)
        # p "vtp编辑中局部："+vtp.to_s
        x值=vtp[0]
        y值=vtp[1]
        z值=vtp[2]

        最小x=vtp[0] if 最小x.nil?
        最大x=vtp[0] if 最大x.nil?
        最小y=vtp[1] if 最小y.nil?
        最大y=vtp[1] if 最大y.nil?
        最小z=vtp[2] if 最小z.nil?
        最大z=vtp[2] if 最大z.nil?

        if x值<最小x
          最小x=x值
        end
        if x值>最大x
          最大x=x值
        end
        if y值<最小y
          最小y=y值
        end
        if y值>最大y
          最大y=y值
        end
        if z值<最小z
          最小z=z值
        end
        if z值>最大z
          最大z=z值
        end
      }

      # p "@左面x:"+@左面x.to_s
      @左面x=最小x if @左面x.nil?
      @右面x=最大x if @右面x.nil?
      @前面y=最大y if @前面y.nil?
      @后面y=最小y if @后面y.nil?
      @上面z=最大z if @上面z.nil?
      @下面z=最小z if @下面z.nil?
    end
  end

end # module amtf_su
